```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>深入理解Netty的Pipeline与Handler链</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #2563eb 0%, #1e40af 100%);
        }
        .code-block {
            background-color: #1e293b;
            color: #f8fafc;
            border-radius: 8px;
            font-family: 'Courier New', Courier, monospace;
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-4px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight {
            background: linear-gradient(90deg, rgba(253, 230, 138, 0.2) 0%, rgba(253, 230, 138, 0) 100%);
            padding: 0.2rem 0.4rem;
            border-radius: 4px;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto">
            <div class="flex items-center mb-6">
                <span class="bg-white bg-opacity-20 px-3 py-1 rounded-full text-sm font-semibold">Netty深度解析</span>
            </div>
            <h1 class="text-4xl md:text-5xl font-bold leading-tight mb-6">
                Netty核心架构：<br>Pipeline与Handler链的奥秘
            </h1>
            <p class="text-xl opacity-90 mb-8 max-w-3xl">
                Pipeline和Handler链是Netty高效网络通信的基石，理解它们的设计原理和运作机制，是掌握高性能网络编程的关键所在。
            </p>
            <div class="flex items-center space-x-4">
                <div class="flex items-center">
                    <i class="fas fa-clock mr-2 opacity-80"></i>
                    <span>阅读时间: 8分钟</span>
                </div>
                <div class="flex items-center">
                    <i class="fas fa-layer-group mr-2 opacity-80"></i>
                    <span>高级主题</span>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Intro Section -->
        <section class="mb-16">
            <p class="text-lg text-slate-600 mb-8 leading-relaxed">
                Netty是一个非常强大的网络通信框架，它的设计非常灵活，其中<span class="highlight font-medium">Pipeline</span>和<span class="highlight font-medium">Handler链</span>是Netty架构中的核心概念。它们不仅是Netty高效能的关键所在，也是理解Netty工作原理和优化网络通信的基础。
            </p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <!-- Pipeline Card -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="bg-blue-100 p-3 rounded-lg mr-4">
                                <i class="fas fa-project-diagram text-blue-600 text-xl"></i>
                            </div>
                            <h3 class="text-2xl font-bold">Pipeline 管道</h3>
                        </div>
                        <p class="text-slate-600">
                            Pipeline（管道）是Netty中处理网络事件流的核心机制，它是由一系列Handler组成的链条。每当一个事件发生时，它会被依次传递给Pipeline中的每一个Handler进行处理。
                        </p>
                    </div>
                </div>
                
                <!-- Handler Chain Card -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="bg-purple-100 p-3 rounded-lg mr-4">
                                <i class="fas fa-link text-purple-600 text-xl"></i>
                            </div>
                            <h3 class="text-2xl font-bold">Handler 链</h3>
                        </div>
                        <p class="text-slate-600">
                            Handler链（Handler Chain）是Pipeline的组成部分，是一系列处理网络事件的Handler对象。每个Handler负责处理Pipeline中的一个特定环节。
                        </p>
                    </div>
                </div>
            </div>
            
            <!-- Mermaid Diagram -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden p-6 mb-12">
                <div class="mermaid">
                    graph LR
                    A[事件进入] --> B[Inbound Handler 1]
                    B --> C[Inbound Handler 2]
                    C --> D[业务逻辑 Handler]
                    D --> E[Outbound Handler 1]
                    E --> F[Outbound Handler 2]
                    F --> G[事件发出]
                </div>
                <p class="text-center text-sm text-slate-500 mt-4">
                    Netty Pipeline处理流程示意图 - 数据从入站处理器流入，经过业务处理后由出站处理器发出
                </p>
            </div>
        </section>
        
        <!-- Pipeline Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-blue-600 rounded mr-4"></div>
                <h2 class="text-3xl font-bold">什么是Pipeline？</h2>
            </div>
            
            <p class="text-lg text-slate-600 mb-6">
                <span class="font-semibold">Pipeline</span>（管道）是Netty中处理网络事件流的核心机制，它是由一系列<span class="font-semibold">Handler</span>组成的链条。每当一个事件发生时，它会被依次传递给Pipeline中的每一个Handler进行处理。Pipeline的设计使得数据处理过程非常灵活和高效，可以根据需要增加、删除、调整处理步骤，从而实现高度的可扩展性和可维护性。在Netty中，Pipeline是一个<span class="font-semibold">责任链模式</span>的实现。每个Handler都是链中的一个处理节点，事件通过这个链传递和处理。
            </p>
            
            <div class="bg-blue-50 border-l-4 border-blue-500 p-4 mb-8">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-info-circle text-blue-500 text-xl"></i>
                    </div>
                    <div class="ml-3">
                        <h3 class="text-sm font-medium text-blue-800">核心概念</h3>
                        <p class="text-sm text-blue-700">
                            Pipeline本质上是责任链模式(Chain of Responsibility Pattern)的一种实现，它定义了处理对象之间的链式结构，使得请求能够沿着这条链传递，直到被处理。
                        </p>
                    </div>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mb-4 text-slate-800">Pipeline的核心作用</h3>
            
            <div class="grid sm:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-lg shadow-sm border border-slate-100">
                    <div class="flex items-center mb-3">
                        <div class="bg-blue-100 p-2 rounded-full mr-3">
                            <i class="fas fa-exchange-alt text-blue-600"></i>
                        </div>
                        <h4 class="font-semibold">事件传递</h4>
                    </div>
                    <p class="text-slate-600 text-sm">
                        Pipeline负责将一个事件（比如数据读取、连接建立等）传递给链条中的每个Handler处理。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border border-slate-100">
                    <div class="flex items-center mb-3">
                        <div class="bg-purple-100 p-2 rounded-full mr-3">
                            <i class="fas fa-tasks text-purple-600"></i>
                        </div>
                        <h4 class="font-semibold">处理责任分配</h4>
                    </div>
                    <p class="text-slate-600 text-sm">
                        每个Handler负责特定的处理逻辑，例如数据解码、业务处理、数据编码等。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border border-slate-100">
                    <div class="flex items-center mb-3">
                        <div class="bg-green-100 p-2 rounded-full mr-3">
                            <i class="fas fa-expand text-green-600"></i>
                        </div>
                        <h4 class="font-semibold">灵活扩展</h4>
                    </div>
                    <p class="text-slate-600 text-sm">
                        通过修改Pipeline的配置，我们可以灵活地控制数据处理的流程、添加新的功能或者调整现有的处理逻辑。
                    </p>
                </div>
            </div>
        </section>
        
        <!-- Handler Chain Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-purple-600 rounded mr-4"></div>
                <h2 class="text-3xl font-bold">什么是Handler链？</h2>
            </div>
            
            <p class="text-lg text-slate-600 mb-6">
                <span class="font-semibold">Handler链</span>（Handler Chain）是Pipeline的组成部分，是一系列处理网络事件的Handler对象。每个Handler负责处理Pipeline中的一个特定环节，可以是数据的解码、编码、业务逻辑处理、异常处理等。
            </p>
            
            <p class="text-lg text-slate-600 mb-8">
                Handler链的工作方式非常类似于Java的<span class="font-semibold">责任链模式</span>，每个Handler有可能会修改传递的消息或者事件，或者将消息转发给链中的下一个Handler。Handler链的顺序是非常重要的，它决定了事件的处理流程。
            </p>
            
            <h3 class="text-2xl font-semibold mb-4 text-slate-800">Handler的类型</h3>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <!-- Inbound Handler -->
                <div class="bg-white rounded-lg shadow-md overflow-hidden">
                    <div class="bg-indigo-600 px-6 py-3">
                        <h4 class="text-white font-semibold text-lg flex items-center">
                            <i class="fas fa-sign-in-alt mr-2"></i> Inbound Handler
                        </h4>
                    </div>
                    <div class="p-6">
                        <p class="text-slate-600 mb-4">
                            入站处理器负责处理从远程对端接收到的数据或事件。例如：
                        </p>
                        <ul class="list-disc pl-5 text-slate-600 space-y-1">
                            <li>数据解码</li>
                            <li>读取事件处理</li>
                            <li>连接建立/关闭事件</li>
                        </ul>
                    </div>
                </div>
                
                <!-- Outbound Handler -->
                <div class="bg-white rounded-lg shadow-md overflow-hidden">
                    <div class="bg-teal-600 px-6 py-3">
                        <h4 class="text-white font-semibold text-lg flex items-center">
                            <i class="fas fa-sign-out-alt mr-2"></i> Outbound Handler
                        </h4>
                    </div>
                    <div class="p-6">
                        <p class="text-slate-600 mb-4">
                            出站处理器负责处理发送到远程对端的数据或事件。例如：
                        </p>
                        <ul class="list-disc pl-5 text-slate-600 space-y-1">
                            <li>数据编码</li>
                            <li>写操作处理</li>
                            <li>数据压缩</li>
                        </ul>
                    </div>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mb-4 text-slate-800">Handler的作用</h3>
            
            <div class="grid sm:grid-cols-2 md:grid-cols-3 gap-4 mb-8">
                <div class="bg-white p-4 rounded-lg border border-slate-100 shadow-sm flex items-start">
                    <div class="bg-blue-100 p-2 rounded-lg mr-3 flex-shrink-0">
                        <i class="fas fa-database text-blue-600"></i>
                    </div>
                    <div>
                        <h4 class="font-medium text-sm mb-1">读取/处理数据</h4>
                        <p class="text-xs text-slate-500">处理从客户端或服务器接收到的数据</p>
                    </div>
                </div>
                
                <div class="bg-white p-4 rounded-lg border border-slate-100 shadow-sm flex items-start">
                    <div class="bg-purple-100 p-2 rounded-lg mr-3 flex-shrink-0">
                        <i class="fas fa-paper-plane text-purple-600"></i>
                    </div>
                    <div>
                        <h4 class="font-medium text-sm mb-1">写入/发送数据</h4>
                        <p class="text-xs text-slate-500">将数据写入到网络连接中发送到对端</p>
                    </div>
                </div>
                
                <div class="bg-white p-4 rounded-lg border border-slate-100 shadow-sm flex items-start">
                    <div class="bg-green-100 p-2 rounded-lg mr-3 flex-shrink-0">
                        <i class="fas fa-code text-green-600"></i>
                    </div>
                    <div>
                        <h4 class="font-medium text-sm mb-1">解码/编码数据</h4>
                        <p class="text-xs text-slate-500">将数据转化为应用层对象或字节流</p>
                    </div>
                </div>
                
                <div class="bg-white p-4 rounded-lg border border-slate-100 shadow-sm flex items-start">
                    <div class="bg-red-100 p-2 rounded-lg mr-3 flex-shrink-0">
                        <i class="fas fa-exclamation-triangle text-red-600"></i>
                    </div>
                    <div>
                        <h4 class="font-medium text-sm mb-1">异常处理</h4>
                        <p class="text-xs text-slate-500">在网络通信过程中捕获并处理异常</p>
                    </div>
                </div>
                
                <div class="bg-white p-4 rounded-lg border border-slate-100 shadow-sm flex items-start">
                    <div class="bg-yellow-100 p-2 rounded-lg mr-3 flex-shrink-0">
                        <i class="fas fa-plug text-yellow-600"></i>
                    </div>
                    <div>
                        <h4 class="font-medium text-sm mb-1">连接管理</h4>
                        <p class="text-xs text-slate-500">处理连接的建立、关闭等事件</p>
                    </div>
                </div>
            </div>
        </section>
        
        <!-- Pipeline Workflow Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-amber-500 rounded mr-4"></div>
                <h2 class="text-3xl font-bold">Pipeline的工作原理</h2>
            </div>
            
            <p class="text-lg text-slate-600 mb-6">
                在Netty中，事件的处理过程是通过<span class="font-semibold">ChannelPipeline</span>来管理的。每当事件发生时，它会进入Pipeline，Pipeline会按照配置好的顺序将事件传递给其中的Handler进行处理。
            </p>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-8">
                <div class="p-6">
                    <div class="flex flex-col md:flex-row items-center mb-6">
                        <div class="w-full md:w-1/2 mb-6 md:mb-0">
                            <h3 class="text-xl font-semibold mb-4">Pipeline工作流程</h3>
                            <ol class="list-decimal pl-5 space-y-3 text-slate-700">
                                <li><span class="font-medium">事件流入Pipeline</span>：当有一个网络事件（如数据读取、连接建立等）发生时，事件会流入ChannelPipeline。</li>
                                <li><span class="font-medium">事件流经Handler链</span>：Pipeline会依次调用链中每个Handler的相应方法，例如`channelRead()`、`write()`等。</li>
                                <li><span class="font-medium">事件处理完毕</span>：当所有Handler都处理完事件后，事件流的处理过程就结束了。如果有需要返回给对端的数据，最后一个Handler会将数据写回去。</li>
                            </ol>
                        </div>
                        <div class="w-full md:w-1/2">
                            <div class="mermaid">
                                sequenceDiagram
                                    participant C as 客户端
                                    participant P as Pipeline
                                    participant H1 as Handler1
                                    participant H2 as Handler2
                                    participant H3 as Handler3
                                    
                                    C->>P: 发送数据
                                    P->>H1: channelRead()
                                    H1->>H2: channelRead()
                                    H2->>H3: channelRead()
                                    H3-->>H2: 处理完成
                                    H2-->>H1: 处理完成
                                    H1-->>P: 处理完成
                                    P->>C: 返回响应
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>
        
        <!-- Example Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-emerald-500 rounded mr-4"></div>
                <h2 class="text-3xl font-bold">示例：Echo服务器的Pipeline和Handler链</h2>
            </div>
            
            <p class="text-lg text-slate-600 mb-6">
                让我们通过一个简单的Echo服务器来直观理解Pipeline和Handler链是如何工作的。
            </p>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-8">
                <div class="bg-slate-800 px-6 py-3 flex justify-between items-center">
                    <h3 class="text-white font-mono">EchoServer.java</h3>
                    <button class="text-slate-300 hover:text-white">
                        <i class="far fa-copy"></i>
                    </button>
                </div>
                <div class="p-6 overflow-x-auto">
                    <pre class="code-block text-sm"><code>public class EchoServer {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 用于处理接收客户端连接
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 用于处理I/O操作

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)  // 使用NIO传输
                    .childHandler(new EchoServerInitializer()); // 配置服务器端的ChannelHandler

            ChannelFuture future = bootstrap.bind(8080).sync(); // 绑定端口并启动
            future.channel().closeFuture().sync();  // 等待服务器端的channel关闭
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

class EchoServerInitializer extends ChannelInitializer&lt;SocketChannel&gt; {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 添加入站处理器（处理接收数据）
        pipeline.addLast(new EchoServerHandler());
    }
}

class EchoServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 将接收到的消息原样发送回去
        ctx.writeAndFlush(msg);
    }
}</code></pre>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mb-4 text-slate-800">代码解析</h3>
            
            <div class="grid md:grid-cols-3 gap-6 mb-8">
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h4 class="font-semibold mb-3 flex items-center">
                        <span class="bg-blue-100 text-blue-800 text-xs font-medium mr-2 px-2.5 py-0.5 rounded">1</span>
                        EchoServer
                    </h4>
                    <p class="text-slate-600 text-sm">
                        这是我们的主服务器，使用了<code class="bg-slate-100 px-1 rounded">ServerBootstrap</code>来启动Netty服务器。我们通过<code class="bg-slate-100 px-1 rounded">childHandler</code>方法指定了<code class="bg-slate-100 px-1 rounded">EchoServerInitializer</code>来配置每个接入的<code class="bg-slate-100 px-1 rounded">SocketChannel</code>。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h4 class="font-semibold mb-3 flex items-center">
                        <span class="bg-blue-100 text-blue-800 text-xs font-medium mr-2 px-2.5 py-0.5 rounded">2</span>
                        EchoServerInitializer
                    </h4>
                    <p class="text-slate-600 text-sm">
                        这是一个<code class="bg-slate-100 px-1 rounded">ChannelInitializer</code>，在<code class="bg-slate-100 px-1 rounded">initChannel</code>方法中，我们将<code class="bg-slate-100 px-1 rounded">EchoServerHandler</code>添加到<code class="bg-slate-100 px-1 rounded">ChannelPipeline</code>中。这样，接收到的每一个消息都会被<code class="bg-slate-100 px-1 rounded">EchoServerHandler</code>处理。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h4 class="font-semibold mb-3 flex items-center">
                        <span class="bg-blue-100 text-blue-800 text-xs font-medium mr-2 px-2.5 py-0.5 rounded">3</span>
                        EchoServerHandler
                    </h4>
                    <p class="text-slate-600 text-sm">
                        这个Handler负责处理接收到的消息，在<code class="bg-slate-100 px-1 rounded">channelRead</code>方法中，直接将接收到的消息原样发送回客户端（即Echo功能）。
                    </p>
                </div>
            </div>
            
            <h3 class="text-2xl font-semibold mb-4 text-slate-800">Pipeline与Handler的执行流程</h3>
            
            <div class="bg-blue-50 rounded-lg p-6 mb-8">
                <ol class="list-decimal pl-5 space-y-3">
                    <li>客户端连接到服务器，<code class="bg-blue-100 px-1 rounded">EchoServerInitializer</code>会被触发，<code class="bg-blue-100 px-1 rounded">EchoServerHandler</code>会被加入到<code class="bg-blue-100 px-1 rounded">ChannelPipeline</code>中。</li>
                    <li>客户端发送数据到服务器时，<code class="bg-blue-100 px-1 rounded">channelRead</code>方法被触发，数据会传递给<code class="bg-blue-100 px-1 rounded">EchoServerHandler</code>进行处理。</li>
                    <li>处理完数据后，<code class="bg-blue-100 px-1 rounded">EchoServerHandler</code>会将数据通过<code class="bg-blue-100 px-1 rounded">ctx.writeAndFlush(msg)</code>返回给客户端。</li>
                </ol>
            </div>
        </section>
        
        <!-- Benefits Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-red-500 rounded mr-4"></div>
                <h2 class="text-3xl font-bold">为什么要使用Pipeline和Handler链？</h2>
            </div>
            
            <p class="text-lg text-slate-600 mb-8">
                在Netty中，使用Pipeline和Handler链有很多好处：
            </p>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 p-3 rounded-lg mr-4">
                            <i class="fas fa-bolt text-green-600"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold">高效的事件处理</h3>
                            <p class="text-slate-600">
                                Pipeline和Handler链提供了高效的事件传递机制，每个Handler只关注自己的逻辑，不会影响其他部分。
                            </p>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-lg mr-4">
                            <i class="fas fa-puzzle-piece text-purple-600"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold">灵活的扩展性</h3>
                            <p class="text-slate-600">
                                通过动态修改Pipeline中的Handler，程序员可以灵活地增加或删除功能模块，满足不同的业务需求。
                            </p>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-3 rounded-lg mr-4">
                            <i class="fas fa-sitemap text-blue-600"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold">清晰的职责划分</h3>
                            <p class="text-slate-600">
                                每个Handler负责处理特定的任务（如编码、解码、处理数据等），代码结构清晰，易于维护。
                            </p>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-center mb-4">
                        <div class="bg-amber-100 p-3 rounded-lg mr-4">
                            <i class="fas fa-unlink text-amber-600"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-semibold">解耦合</h3>
                            <p class="text-slate-600">
                                Handler之间的解耦使得网络通信的各个环节可以单独修改或替换，增加了系统的可维护性。
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-slate-900 text-white py-12 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-semibold">技术小馆</h3>
                    <p class="text-slate-400 mt-1">探索技术奥秘，分享编程心得</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-slate-300 hover:text-white transition-colors duration-200 flex items-center">
                        <i class="fas fa-external-link-alt mr-2"></i>
                        <span>访问技术小馆</span>
                    </a>
                </div>
            </div>
            <div class="border-t border-slate-700 mt-8 pt-8 text-sm text-slate-400 text-center">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'dark',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // Copy code block functionality
        document.querySelectorAll('.fa-copy').forEach(button => {
            button.addEventListener('click', () => {
                const codeBlock = button.closest('.bg-slate-800').nextElementSibling.querySelector('code');
                const text = codeBlock.innerText;
                
                navigator.clipboard.writeText(text).then(() => {
                    button.innerHTML = '<i class="fas fa-check"></i>';
                    setTimeout(() => {
                        button.innerHTML = '<i class="far fa-copy"></i>';
                    }, 2000);
                });
            });
        });
    </script>
</body>
</html>
```